// API服务类，处理所有网络请求和数据管理
export interface User {
  username: string;
  password: string; // 实际应用中应加密存储
  email?: string;
  phone?: string;
}

export interface Message {
  id: string;
  content: string;
  sender: 'user' | 'bot';
  timestamp: string;
  image?: string;
  emotion?: string;
}

export interface HealthData {
  userId: string;
  height?: number;
  weight?: number;
  bloodPressure?: string;
  bloodSugar?: number;
  heartRate?: number;
  allergies?: string;
  medicalHistory?: string;
  medications?: string;
  lastUpdate?: string;
}

export interface MedicalReport {
  id: string;
  userId: string;
  reportDate: string;
  symptoms: string;
  diagnosis: string;
  severity: 'low' | 'medium' | 'high';
  recommendations: string[];
  causes: string;
  nextSteps: string;
}

export interface Medicine {
  id: string;
  name: string;
  effects: string;
  usageDosage: string;
  contraindications: string;
  sideEffects: string;
  buyLink: string;
}

export class ApiService {
  private static instance: ApiService;
  private preferences: any = null;
  private abilityContext: any = null;

  private constructor() {
    // 构造函数中不进行异步初始化
  }

  public static getInstance(): ApiService {
    if (!ApiService.instance) {
      ApiService.instance = new ApiService();
    }
    return ApiService.instance;
  }

  // 设置abilityContext
  public setAbilityContext(context: any): void {
    this.abilityContext = context;
    // 设置context后初始化preferences
    this.initPreferences();
  }

  private async initPreferences() {
    try {
      console.log('初始化Preferences...');
    } catch (error) {
      console.error('初始化Preferences失败:', error);
    }
  }

  // 用户登录
  public async login(username: string, password: string): Promise<{ success: boolean; message: string }> {
    try {
      // 在实际应用中，这里应该调用真实的登录API
      // 这里使用模拟数据进行验证
      if (username && password) {
        // 存储登录状态
        if (this.preferences) {
          await this.preferences.put('isLoggedIn', true);
          await this.preferences.put('username', username);
          await this.preferences.flush();
        }
        this.abilityContext?.storage?.set('isLoggedIn', true);
        if (this.abilityContext && this.abilityContext.storage) {
          this.abilityContext.storage.set('username', username);
        }
        return { success: true, message: '登录成功' };
      } else {
        return { success: false, message: '用户名和密码不能为空' };
      }
    } catch (error) {
      console.error('登录失败:', error);
      return { success: false, message: '登录失败，请重试' };
    }
  }

  // 用户注册
  public async register(username: string, password: string): Promise<{ success: boolean; message: string }> {
    try {
      // 在实际应用中，这里应该调用真实的注册API
      if (!username || !password) {
        return { success: false, message: '用户名和密码不能为空' };
      }
      if (password.length < 6) {
        return { success: false, message: '密码长度不能少于6位' };
      }
      
      // 模拟注册成功
      return { success: true, message: '注册成功' };
    } catch (error) {
      console.error('注册失败:', error);
      return { success: false, message: '注册失败，请重试' };
    }
  }

  // 用户登出
  public async logout(): Promise<void> {
    try {
      if (this.preferences) {
        await this.preferences.put('isLoggedIn', false);
        await this.preferences.delete('username');
        await this.preferences.flush();
      }
      // 使用 abilityContext 的 storage 替代 AppStorage
      if (this.abilityContext && this.abilityContext.storage) {
        this.abilityContext.storage.set('isLoggedIn', false);
      }
      if (this.abilityContext && this.abilityContext.storage) {
        this.abilityContext.storage.delete('username');
      }
    } catch (error) {
      console.error('登出失败:', error);
    }
  }

  // 获取聊天回复
  public async getChatResponse(message: string, healthData?: HealthData): Promise<Message> {
    try {
      // 在实际应用中，这里应该调用AI模型API
      // 这里使用模拟的回复逻辑
      let response = '';
      
      // 根据不同的健康问题提供不同的回答
      if (message.includes('头痛') || message.includes('头疼')) {
        response = '您好，头痛可能由多种原因引起，如压力、疲劳、感冒或偏头痛等。建议您：1) 保证充足的睡眠 2) 避免长时间看屏幕 3) 保持水分摄入 4) 如果头痛持续或加剧，请咨询专业医生。';
      } else if (message.includes('发烧') || message.includes('发热')) {
        response = '发烧是身体对抗感染的自然反应。如果体温低于38.5°C，可以：1) 多喝水 2) 休息 3) 物理降温。如果体温超过38.5°C或伴有严重症状，建议服用退烧药并及时就医。';
      } else if (message.includes('咳嗽')) {
        response = '咳嗽可能是呼吸道感染的症状。建议：1) 多喝水 2) 避免刺激性食物 3) 保持室内湿度 4) 如果咳嗽持续超过一周或伴有血痰，请尽快就医。';
      } else if (message.includes('血压')) {
        response = '血压异常需要重视。正常血压范围是收缩压90-140mmHg，舒张压60-90mmHg。建议：1) 定期测量 2) 减少盐分摄入 3) 适量运动 4) 戒烟限酒 5) 如有异常请咨询医生。';
      } else {
        response = '感谢您的咨询。根据您的描述，我建议您注意观察症状变化，保持良好的生活习惯。如果症状持续或加重，请及时就医，以便获得准确的诊断和治疗。';
      }
      
      return {
        id: Date.now().toString(),
        content: response,
        sender: 'bot',
        timestamp: new Date().toISOString(),
        emotion: this.analyzeEmotion(response)
      };
    } catch (error) {
      console.error('获取聊天回复失败:', error);
      return {
        id: Date.now().toString(),
        content: '抱歉，我暂时无法回答您的问题，请稍后再试。',
        sender: 'bot',
        timestamp: new Date().toISOString()
      };
    }
  }

  // 情绪分析
  private analyzeEmotion(text: string): string {
    // 简单的情绪分析逻辑
    const positiveWords = ['建议', '良好', '正常', '健康', '规律'];
    const negativeWords = ['症状', '问题', '异常', '严重', '就医'];
    
    let positiveCount = 0;
    let negativeCount = 0;
    
    positiveWords.forEach(word => {
      if (text.includes(word)) positiveCount++;
    });
    
    negativeWords.forEach(word => {
      if (text.includes(word)) negativeCount++;
    });
    
    if (positiveCount > negativeCount) return 'positive';
    if (negativeCount > positiveCount) return 'negative';
    return 'neutral';
  }

  // 保存健康数据
  public async saveHealthData(data: HealthData): Promise<boolean> {
    try {
      if (this.preferences) {
        const jsonData = JSON.stringify({
          ...data,
          lastUpdate: new Date().toISOString()
        });
        await this.preferences.put('healthData', jsonData);
        await this.preferences.flush();
        return true;
      }
      console.warn('Preferences未初始化，无法保存健康数据');
      return false;
    } catch (error) {
      console.error('保存健康数据失败:', error);
      return false;
    }
  }

  // 获取健康数据
  public async getHealthData(): Promise<HealthData | null> {
    try {
      if (this.preferences) {
        const jsonData = await this.preferences.get('healthData', '');
        if (jsonData && typeof jsonData === 'string') {
          return JSON.parse(jsonData);
        }
      } else {
        console.warn('Preferences未初始化，无法获取健康数据');
      }
      return null;
    } catch (error) {
      console.error('获取健康数据失败:', error);
      return null;
    }
  }

  // 生成医疗报告
  public async generateMedicalReport(symptoms: string, healthData?: HealthData): Promise<MedicalReport> {
    try {
      // 在实际应用中，这里应该基于AI分析生成报告
      // 这里使用模拟数据
      const report: MedicalReport = {
        id: Date.now().toString(),
        userId: healthData?.userId || 'default_user',
        reportDate: new Date().toISOString(),
        symptoms: symptoms,
        diagnosis: this.getDiagnosis(symptoms),
        severity: this.getSeverity(symptoms),
        recommendations: this.getRecommendations(symptoms),
        causes: this.getCauses(symptoms),
        nextSteps: '建议密切观察症状变化，如有异常及时就医。保持良好的生活习惯和饮食习惯。'
      };
      
      // 保存报告
      const reports = await this.getMedicalReports();
      reports.push(report);
      if (this.preferences) {
        await this.preferences.put('medicalReports', JSON.stringify(reports));
        await this.preferences.flush();
      }
      
      return report;
    } catch (error) {
      console.error('生成医疗报告失败:', error);
      throw error;
    }
  }

  // 获取所有医疗报告
  public async getMedicalReports(): Promise<MedicalReport[]> {
    try {
      if (this.preferences) {
        const jsonData = await this.preferences.get('medicalReports', '[]');
        if (typeof jsonData === 'string') {
          return JSON.parse(jsonData);
        }
      } else {
        console.warn('Preferences未初始化，返回空报告列表');
      }
      return [];
    } catch (error) {
      console.error('获取医疗报告失败:', error);
      return [];
    }
  }

  // 根据症状获取诊断（模拟）
  private getDiagnosis(symptoms: string): string {
    if (symptoms.includes('头痛') && symptoms.includes('恶心')) {
      return '可能为偏头痛';
    } else if (symptoms.includes('发热') && symptoms.includes('咳嗽')) {
      return '可能为普通感冒或流感';
    } else if (symptoms.includes('腹痛') && symptoms.includes('腹泻')) {
      return '可能为急性肠胃炎';
    } else {
      return '根据描述的症状，需要进一步观察和检查';
    }
  }

  // 获取严重程度（模拟）
  private getSeverity(symptoms: string): 'low' | 'medium' | 'high' {
    if (symptoms.includes('严重') || symptoms.includes('剧烈') || symptoms.includes('持续')) {
      return 'high';
    } else if (symptoms.includes('中度') || symptoms.includes('几天')) {
      return 'medium';
    } else {
      return 'low';
    }
  }

  // 获取建议（模拟）
  private getRecommendations(symptoms: string): string[] {
    const recommendations: string[] = [];
    
    if (symptoms.includes('头痛')) {
      recommendations.push('避免强光和噪音');
      recommendations.push('保持充足睡眠');
      recommendations.push('可以尝试按摩太阳穴');
    }
    
    if (symptoms.includes('发热')) {
      recommendations.push('多喝水');
      recommendations.push('注意休息');
      recommendations.push('监测体温变化');
    }
    
    if (symptoms.includes('咳嗽')) {
      recommendations.push('保持室内湿度');
      recommendations.push('避免刺激性食物');
      recommendations.push('可以尝试蜂蜜水缓解');
    }
    
    recommendations.push('如症状加重请及时就医');
    return recommendations;
  }

  // 获取可能的原因（模拟）
  private getCauses(symptoms: string): string {
    if (symptoms.includes('头痛')) {
      return '可能由压力、疲劳、偏头痛、高血压或其他潜在疾病引起';
    } else if (symptoms.includes('发热')) {
      return '可能由病毒或细菌感染、炎症反应或其他疾病引起';
    } else if (symptoms.includes('咳嗽')) {
      return '可能由呼吸道感染、过敏反应、空气污染或其他呼吸系统问题引起';
    } else {
      return '症状可能由多种因素引起，需要进一步检查确定';
    }
  }

  // 搜索药品
  public async searchMedicine(keyword: string): Promise<Medicine[]> {
    try {
      // 在实际应用中，这里应该调用药品数据库API
      // 这里使用模拟数据
      const mockMedicines: Medicine[] = [
        {
          id: '1',
          name: '布洛芬片',
          effects: '用于缓解轻至中度疼痛如头痛、关节痛、偏头痛、牙痛、肌肉痛、神经痛、痛经。也用于普通感冒或流行性感冒引起的发热。',
          usageDosage: '成人一次0.2-0.4g，每4-6小时一次，24小时内不超过2.4g。',
          contraindications: '对布洛芬过敏者禁用；活动期消化道溃疡患者禁用；严重肝肾功能不全者禁用。',
          sideEffects: '可能出现恶心、呕吐、胃痛、消化不良、头晕、头痛等不良反应。',
          buyLink: 'https://example.com/med1'
        },
        {
          id: '2',
          name: '复方感冒灵颗粒',
          effects: '用于感冒引起的头痛、发热、鼻塞、流涕、咽痛等症状。',
          usageDosage: '一次1袋，一日3次，温开水冲服。',
          contraindications: '严重肝肾功能不全者禁用；对本品过敏者禁用。',
          sideEffects: '可能出现困倦、嗜睡、口渴、虚弱感等不良反应。',
          buyLink: 'https://example.com/med2'
        },
        {
          id: '3',
          name: '盐酸氨溴索口服溶液',
          effects: '用于急性、慢性呼吸道疾病如急性支气管炎、慢性支气管炎伴有痰液粘稠、排痰困难者。',
          usageDosage: '成人及12岁以上儿童：一次10ml，一日2次。',
          contraindications: '对氨溴索过敏者禁用；妊娠早期妇女禁用。',
          sideEffects: '可能出现胃部不适、恶心、皮疹等不良反应。',
          buyLink: 'https://example.com/med3'
        }
      ];
      
      // 简单的搜索逻辑
      return mockMedicines.filter(medicine => 
        medicine.name.includes(keyword) || 
        medicine.effects.includes(keyword)
      );
    } catch (error) {
      console.error('搜索药品失败:', error);
      return [];
    }
  }

  // 获取健康科普内容
  public async getHealthArticles(topic?: string): Promise<Array<{ id: string; title: string; content: string; date: string }>> {
    try {
      // 模拟健康科普文章数据
      const articles = [
        {
          id: '1',
          title: '如何有效预防感冒',
          content: '感冒是常见的呼吸道感染疾病，预防措施包括：1) 勤洗手 2) 避免接触感冒患者 3) 加强锻炼 4) 保持充足睡眠 5) 均衡饮食 6) 保持室内通风。',
          date: '2024-01-15'
        },
        {
          id: '2',
          title: '健康饮食的基本原则',
          content: '健康饮食应遵循以下原则：1) 食物多样化 2) 控制总热量摄入 3) 增加蔬菜水果摄入 4) 减少盐分和糖分 5) 选择优质蛋白质 6) 规律进餐。',
          date: '2024-01-10'
        },
        {
          id: '3',
          title: '适量运动对健康的益处',
          content: '适量运动有助于：1) 增强心肺功能 2) 提高免疫力 3) 控制体重 4) 改善睡眠质量 5) 缓解压力和焦虑 6) 预防慢性疾病。建议每周至少进行150分钟中等强度的有氧运动。',
          date: '2024-01-05'
        }
      ];
      
      if (topic) {
        return articles.filter(article => 
          article.title.includes(topic) || 
          article.content.includes(topic)
        );
      }
      
      return articles;
    } catch (error) {
      console.error('获取健康科普内容失败:', error);
      return [];
    }
  }
}